home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / lib / python2.6 / sgmllib.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2009-11-11  |  16KB  |  588 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. '''A parser for SGML, using the derived class as a static DTD.'''
  5. from warnings import warnpy3k
  6. warnpy3k('the sgmllib module has been removed in Python 3.0', stacklevel = 2)
  7. del warnpy3k
  8. import markupbase
  9. import re
  10. __all__ = [
  11.     'SGMLParser',
  12.     'SGMLParseError']
  13. interesting = re.compile('[&<]')
  14. incomplete = re.compile('&([a-zA-Z][a-zA-Z0-9]*|#[0-9]*)?|<([a-zA-Z][^<>]*|/([a-zA-Z][^<>]*)?|![^<>]*)?')
  15. entityref = re.compile('&([a-zA-Z][-.a-zA-Z0-9]*)[^a-zA-Z0-9]')
  16. charref = re.compile('&#([0-9]+)[^0-9]')
  17. starttagopen = re.compile('<[>a-zA-Z]')
  18. shorttagopen = re.compile('<[a-zA-Z][-.a-zA-Z0-9]*/')
  19. shorttag = re.compile('<([a-zA-Z][-.a-zA-Z0-9]*)/([^/]*)/')
  20. piclose = re.compile('>')
  21. endbracket = re.compile('[<>]')
  22. tagfind = re.compile('[a-zA-Z][-_.a-zA-Z0-9]*')
  23. attrfind = re.compile('\\s*([a-zA-Z_][-:.a-zA-Z_0-9]*)(\\s*=\\s*(\\\'[^\\\']*\\\'|"[^"]*"|[][\\-a-zA-Z0-9./,:;+*%?!&$\\(\\)_#=~\\\'"@]*))?')
  24.  
  25. class SGMLParseError(RuntimeError):
  26.     '''Exception raised for all parse errors.'''
  27.     pass
  28.  
  29.  
  30. class SGMLParser(markupbase.ParserBase):
  31.     entity_or_charref = re.compile('&(?:([a-zA-Z][-.a-zA-Z0-9]*)|#([0-9]+))(;?)')
  32.     
  33.     def __init__(self, verbose = 0):
  34.         '''Initialize and reset this instance.'''
  35.         self.verbose = verbose
  36.         self.reset()
  37.  
  38.     
  39.     def reset(self):
  40.         '''Reset this instance. Loses all unprocessed data.'''
  41.         self._SGMLParser__starttag_text = None
  42.         self.rawdata = ''
  43.         self.stack = []
  44.         self.lasttag = '???'
  45.         self.nomoretags = 0
  46.         self.literal = 0
  47.         markupbase.ParserBase.reset(self)
  48.  
  49.     
  50.     def setnomoretags(self):
  51.         '''Enter literal mode (CDATA) till EOF.
  52.  
  53.         Intended for derived classes only.
  54.         '''
  55.         self.nomoretags = self.literal = 1
  56.  
  57.     
  58.     def setliteral(self, *args):
  59.         '''Enter literal mode (CDATA).
  60.  
  61.         Intended for derived classes only.
  62.         '''
  63.         self.literal = 1
  64.  
  65.     
  66.     def feed(self, data):
  67.         """Feed some data to the parser.
  68.  
  69.         Call this as often as you want, with as little or as much text
  70.         as you want (may include '
  71. ').  (This just saves the text,
  72.         all the processing is done by goahead().)
  73.         """
  74.         self.rawdata = self.rawdata + data
  75.         self.goahead(0)
  76.  
  77.     
  78.     def close(self):
  79.         '''Handle the remaining data.'''
  80.         self.goahead(1)
  81.  
  82.     
  83.     def error(self, message):
  84.         raise SGMLParseError(message)
  85.  
  86.     
  87.     def goahead(self, end):
  88.         rawdata = self.rawdata
  89.         i = 0
  90.         n = len(rawdata)
  91.         while i < n:
  92.             if self.nomoretags:
  93.                 self.handle_data(rawdata[i:n])
  94.                 i = n
  95.                 break
  96.             
  97.             match = interesting.search(rawdata, i)
  98.             if match:
  99.                 j = match.start()
  100.             else:
  101.                 j = n
  102.             if i < j:
  103.                 self.handle_data(rawdata[i:j])
  104.             
  105.             i = j
  106.             if i == n:
  107.                 break
  108.             
  109.             if rawdata[i] == '<':
  110.                 if starttagopen.match(rawdata, i):
  111.                     if self.literal:
  112.                         self.handle_data(rawdata[i])
  113.                         i = i + 1
  114.                         continue
  115.                     
  116.                     k = self.parse_starttag(i)
  117.                     if k < 0:
  118.                         break
  119.                     
  120.                     i = k
  121.                     continue
  122.                 
  123.                 if rawdata.startswith('</', i):
  124.                     k = self.parse_endtag(i)
  125.                     if k < 0:
  126.                         break
  127.                     
  128.                     i = k
  129.                     self.literal = 0
  130.                     continue
  131.                 
  132.                 if self.literal:
  133.                     if n > i + 1:
  134.                         self.handle_data('<')
  135.                         i = i + 1
  136.                         continue
  137.                     break
  138.                     continue
  139.                 
  140.                 if rawdata.startswith('<!--', i):
  141.                     k = self.parse_comment(i)
  142.                     if k < 0:
  143.                         break
  144.                     
  145.                     i = k
  146.                     continue
  147.                 
  148.                 if rawdata.startswith('<?', i):
  149.                     k = self.parse_pi(i)
  150.                     if k < 0:
  151.                         break
  152.                     
  153.                     i = i + k
  154.                     continue
  155.                 
  156.                 if rawdata.startswith('<!', i):
  157.                     k = self.parse_declaration(i)
  158.                     if k < 0:
  159.                         break
  160.                     
  161.                     i = k
  162.                     continue
  163.                 
  164.             elif rawdata[i] == '&':
  165.                 if self.literal:
  166.                     self.handle_data(rawdata[i])
  167.                     i = i + 1
  168.                     continue
  169.                 
  170.                 match = charref.match(rawdata, i)
  171.                 if match:
  172.                     name = match.group(1)
  173.                     self.handle_charref(name)
  174.                     i = match.end(0)
  175.                     if rawdata[i - 1] != ';':
  176.                         i = i - 1
  177.                         continue
  178.                     continue
  179.                 
  180.                 match = entityref.match(rawdata, i)
  181.                 if match:
  182.                     name = match.group(1)
  183.                     self.handle_entityref(name)
  184.                     i = match.end(0)
  185.                     if rawdata[i - 1] != ';':
  186.                         i = i - 1
  187.                         continue
  188.                     continue
  189.                 
  190.             else:
  191.                 self.error('neither < nor & ??')
  192.             match = incomplete.match(rawdata, i)
  193.             if not match:
  194.                 self.handle_data(rawdata[i])
  195.                 i = i + 1
  196.                 continue
  197.             
  198.             j = match.end(0)
  199.             if j == n:
  200.                 break
  201.             
  202.             self.handle_data(rawdata[i:j])
  203.             i = j
  204.         if end and i < n:
  205.             self.handle_data(rawdata[i:n])
  206.             i = n
  207.         
  208.         self.rawdata = rawdata[i:]
  209.  
  210.     _decl_otherchars = '='
  211.     
  212.     def parse_pi(self, i):
  213.         rawdata = self.rawdata
  214.         if rawdata[i:i + 2] != '<?':
  215.             self.error('unexpected call to parse_pi()')
  216.         
  217.         match = piclose.search(rawdata, i + 2)
  218.         if not match:
  219.             return -1
  220.         j = match.start(0)
  221.         self.handle_pi(rawdata[i + 2:j])
  222.         j = match.end(0)
  223.         return j - i
  224.  
  225.     
  226.     def get_starttag_text(self):
  227.         return self._SGMLParser__starttag_text
  228.  
  229.     
  230.     def parse_starttag(self, i):
  231.         self._SGMLParser__starttag_text = None
  232.         start_pos = i
  233.         rawdata = self.rawdata
  234.         if shorttagopen.match(rawdata, i):
  235.             match = shorttag.match(rawdata, i)
  236.             if not match:
  237.                 return -1
  238.             (tag, data) = match.group(1, 2)
  239.             self._SGMLParser__starttag_text = '<%s/' % tag
  240.             tag = tag.lower()
  241.             k = match.end(0)
  242.             self.finish_shorttag(tag, data)
  243.             self._SGMLParser__starttag_text = rawdata[start_pos:match.end(1) + 1]
  244.             return k
  245.         match = endbracket.search(rawdata, i + 1)
  246.         if not match:
  247.             return -1
  248.         j = match.start(0)
  249.         attrs = []
  250.         if rawdata[i:i + 2] == '<>':
  251.             k = j
  252.             tag = self.lasttag
  253.         else:
  254.             match = tagfind.match(rawdata, i + 1)
  255.             if not match:
  256.                 self.error('unexpected call to parse_starttag')
  257.             
  258.             k = match.end(0)
  259.             tag = rawdata[i + 1:k].lower()
  260.             self.lasttag = tag
  261.         while k < j:
  262.             match = attrfind.match(rawdata, k)
  263.             if not match:
  264.                 break
  265.             
  266.             (attrname, rest, attrvalue) = match.group(1, 2, 3)
  267.             if not rest:
  268.                 attrvalue = attrname
  269.             elif "'" == "'":
  270.                 pass
  271.             elif not "'" == attrvalue[-1:]:
  272.                 if '"' == '"':
  273.                     pass
  274.                 elif '"' == attrvalue[-1:]:
  275.                     attrvalue = attrvalue[1:-1]
  276.                 
  277.             attrvalue = self.entity_or_charref.sub(self._convert_ref, attrvalue)
  278.             attrs.append((attrname.lower(), attrvalue))
  279.             k = match.end(0)
  280.             continue
  281.             attrvalue[:1]
  282.         if rawdata[j] == '>':
  283.             j = j + 1
  284.         
  285.         self._SGMLParser__starttag_text = rawdata[start_pos:j]
  286.         self.finish_starttag(tag, attrs)
  287.         return j
  288.  
  289.     
  290.     def _convert_ref(self, match):
  291.         if match.group(2):
  292.             if not self.convert_charref(match.group(2)):
  293.                 pass
  294.             return '&#%s%s' % match.groups()[1:]
  295.         if match.group(3):
  296.             if not self.convert_entityref(match.group(1)):
  297.                 pass
  298.             return '&%s;' % match.group(1)
  299.         return '&%s' % match.group(1)
  300.  
  301.     
  302.     def parse_endtag(self, i):
  303.         rawdata = self.rawdata
  304.         match = endbracket.search(rawdata, i + 1)
  305.         if not match:
  306.             return -1
  307.         j = match.start(0)
  308.         tag = rawdata[i + 2:j].strip().lower()
  309.         if rawdata[j] == '>':
  310.             j = j + 1
  311.         
  312.         self.finish_endtag(tag)
  313.         return j
  314.  
  315.     
  316.     def finish_shorttag(self, tag, data):
  317.         self.finish_starttag(tag, [])
  318.         self.handle_data(data)
  319.         self.finish_endtag(tag)
  320.  
  321.     
  322.     def finish_starttag(self, tag, attrs):
  323.         
  324.         try:
  325.             method = getattr(self, 'start_' + tag)
  326.         except AttributeError:
  327.             
  328.             try:
  329.                 method = getattr(self, 'do_' + tag)
  330.             except AttributeError:
  331.                 self.unknown_starttag(tag, attrs)
  332.                 return -1
  333.  
  334.             self.handle_starttag(tag, method, attrs)
  335.             return 0
  336.  
  337.         self.stack.append(tag)
  338.         self.handle_starttag(tag, method, attrs)
  339.         return 1
  340.  
  341.     
  342.     def finish_endtag(self, tag):
  343.         if not tag:
  344.             found = len(self.stack) - 1
  345.             if found < 0:
  346.                 self.unknown_endtag(tag)
  347.                 return None
  348.         elif tag not in self.stack:
  349.             
  350.             try:
  351.                 method = getattr(self, 'end_' + tag)
  352.             except AttributeError:
  353.                 self.unknown_endtag(tag)
  354.  
  355.             self.report_unbalanced(tag)
  356.             return None
  357.         found = len(self.stack)
  358.         for i in range(found):
  359.             if self.stack[i] == tag:
  360.                 found = i
  361.                 continue
  362.         
  363.         while len(self.stack) > found:
  364.             tag = self.stack[-1]
  365.             
  366.             try:
  367.                 method = getattr(self, 'end_' + tag)
  368.             except AttributeError:
  369.                 method = None
  370.  
  371.             if method:
  372.                 self.handle_endtag(tag, method)
  373.             else:
  374.                 self.unknown_endtag(tag)
  375.             del self.stack[-1]
  376.  
  377.     
  378.     def handle_starttag(self, tag, method, attrs):
  379.         method(attrs)
  380.  
  381.     
  382.     def handle_endtag(self, tag, method):
  383.         method()
  384.  
  385.     
  386.     def report_unbalanced(self, tag):
  387.         if self.verbose:
  388.             print '*** Unbalanced </' + tag + '>'
  389.             print '*** Stack:', self.stack
  390.         
  391.  
  392.     
  393.     def convert_charref(self, name):
  394.         '''Convert character reference, may be overridden.'''
  395.         
  396.         try:
  397.             n = int(name)
  398.         except ValueError:
  399.             return None
  400.  
  401.         if n <= n:
  402.             pass
  403.         elif not n <= 127:
  404.             return None
  405.         return self.convert_codepoint(n)
  406.  
  407.     
  408.     def convert_codepoint(self, codepoint):
  409.         return chr(codepoint)
  410.  
  411.     
  412.     def handle_charref(self, name):
  413.         '''Handle character reference, no need to override.'''
  414.         replacement = self.convert_charref(name)
  415.         if replacement is None:
  416.             self.unknown_charref(name)
  417.         else:
  418.             self.handle_data(replacement)
  419.  
  420.     entitydefs = {
  421.         'lt': '<',
  422.         'gt': '>',
  423.         'amp': '&',
  424.         'quot': '"',
  425.         'apos': "'" }
  426.     
  427.     def convert_entityref(self, name):
  428.         '''Convert entity references.
  429.  
  430.         As an alternative to overriding this method; one can tailor the
  431.         results by setting up the self.entitydefs mapping appropriately.
  432.         '''
  433.         table = self.entitydefs
  434.         if name in table:
  435.             return table[name]
  436.         return None
  437.  
  438.     
  439.     def handle_entityref(self, name):
  440.         '''Handle entity references, no need to override.'''
  441.         replacement = self.convert_entityref(name)
  442.         if replacement is None:
  443.             self.unknown_entityref(name)
  444.         else:
  445.             self.handle_data(replacement)
  446.  
  447.     
  448.     def handle_data(self, data):
  449.         pass
  450.  
  451.     
  452.     def handle_comment(self, data):
  453.         pass
  454.  
  455.     
  456.     def handle_decl(self, decl):
  457.         pass
  458.  
  459.     
  460.     def handle_pi(self, data):
  461.         pass
  462.  
  463.     
  464.     def unknown_starttag(self, tag, attrs):
  465.         pass
  466.  
  467.     
  468.     def unknown_endtag(self, tag):
  469.         pass
  470.  
  471.     
  472.     def unknown_charref(self, ref):
  473.         pass
  474.  
  475.     
  476.     def unknown_entityref(self, ref):
  477.         pass
  478.  
  479.  
  480.  
  481. class TestSGMLParser(SGMLParser):
  482.     
  483.     def __init__(self, verbose = 0):
  484.         self.testdata = ''
  485.         SGMLParser.__init__(self, verbose)
  486.  
  487.     
  488.     def handle_data(self, data):
  489.         self.testdata = self.testdata + data
  490.         if len(repr(self.testdata)) >= 70:
  491.             self.flush()
  492.         
  493.  
  494.     
  495.     def flush(self):
  496.         data = self.testdata
  497.         if data:
  498.             self.testdata = ''
  499.             print 'data:', repr(data)
  500.         
  501.  
  502.     
  503.     def handle_comment(self, data):
  504.         self.flush()
  505.         r = repr(data)
  506.         if len(r) > 68:
  507.             r = r[:32] + '...' + r[-32:]
  508.         
  509.         print 'comment:', r
  510.  
  511.     
  512.     def unknown_starttag(self, tag, attrs):
  513.         self.flush()
  514.         if not attrs:
  515.             print 'start tag: <' + tag + '>'
  516.         else:
  517.             print 'start tag: <' + tag,
  518.             for name, value in attrs:
  519.                 print name + '=' + '"' + value + '"',
  520.             
  521.             print '>'
  522.  
  523.     
  524.     def unknown_endtag(self, tag):
  525.         self.flush()
  526.         print 'end tag: </' + tag + '>'
  527.  
  528.     
  529.     def unknown_entityref(self, ref):
  530.         self.flush()
  531.         print '*** unknown entity ref: &' + ref + ';'
  532.  
  533.     
  534.     def unknown_charref(self, ref):
  535.         self.flush()
  536.         print '*** unknown char ref: &#' + ref + ';'
  537.  
  538.     
  539.     def unknown_decl(self, data):
  540.         self.flush()
  541.         print '*** unknown decl: [' + data + ']'
  542.  
  543.     
  544.     def close(self):
  545.         SGMLParser.close(self)
  546.         self.flush()
  547.  
  548.  
  549.  
  550. def test(args = None):
  551.     import sys as sys
  552.     if args is None:
  553.         args = sys.argv[1:]
  554.     
  555.     if args and args[0] == '-s':
  556.         args = args[1:]
  557.         klass = SGMLParser
  558.     else:
  559.         klass = TestSGMLParser
  560.     if args:
  561.         file = args[0]
  562.     else:
  563.         file = 'test.html'
  564.     if file == '-':
  565.         f = sys.stdin
  566.     else:
  567.         
  568.         try:
  569.             f = open(file, 'r')
  570.         except IOError:
  571.             msg = None
  572.             print file, ':', msg
  573.             sys.exit(1)
  574.  
  575.     data = f.read()
  576.     if f is not sys.stdin:
  577.         f.close()
  578.     
  579.     x = klass()
  580.     for c in data:
  581.         x.feed(c)
  582.     
  583.     x.close()
  584.  
  585. if __name__ == '__main__':
  586.     test()
  587.  
  588.